-------------------------------------------------------------------------------
| Metroid Password Format Guide
| by John David Ratliff
|
| The most recent version of this guide can always be found at
| http://games.technoplaza.net/mpg/password.txt
|
| Copyright (C) 2005 emuWorks (http://games.technoplaza.net/)
|   Permission is granted to copy, distribute and/or modify this document
|   under the terms of the GNU Free Documentation License, Version 1.2
|   or any later version published by the Free Software Foundation;
|   with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
|   Texts.  A copy of the license can be found at
|   http://www.gnu.org/licenses/fdl.html
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
| Table of Contents
-------------------------------------------------------------------------------

  1.0 Introduction
  2.0 Copyright Notice
  3.0 Revision History
  4.0 Password Data
    4.1 Basics
    4.2 The Metroid Alphabet
    4.3 The Checksum
    4.4 The Shift Byte
    4.5 Known Password Bits
    4.6 Encoding
    4.7 Decoding
    4.8 The Debug Password
  5.0 mpg - The Metroid Password Generator
  6.0 Credits & Acknowledgments
  7.0 Contact Information
  
-------------------------------------------------------------------------------
| 1.0 Introduction
-------------------------------------------------------------------------------

  This document is a guide to the password system used by Metroid for the NES.
  It applies to the original Metroid 1 released in the US and Europe. I believe
  the information is also accurate for the hidden Metroid 1 game that can be
  unlocked in Metroid Prime, and for Metroid Zero Mission for Game Boy
  Advance. I have only tested the information with the original Metroid for
  the US version of Metroid. Please contact me if you find anything to be
  inaccurate, either as it applies to the Metroid 1 for the NES or any of the
  others mentioned.
  
  This guide is not a walkthrough for Metroid, and will probably not really
  help you create passwords. This guide is a document describing the password
  format for anyone who may be interested in it. I'm writing it because there
  doesn't seem to be any document to describe the password format in and of
  itself. The only thing close is the documentation contained with SnoBro's
  metroid password generator (MetCode) and its source code.
  
  If you just want to create passwords, I suggest using a password generator.
  There are several choices, but because I have written one, it's the one I'm
  going to recommend. You can find my program, mpg (Metroid Password
  Generator), on emuWorks at http://games.technoplaza.net/mpg/. I wrote the
  program to help me learn about the password format so that I could write this
  document.

-------------------------------------------------------------------------------
| 2.0 Copyright Notice
-------------------------------------------------------------------------------

  This document is Copyright (C) 2005 emuWorks (http://games.technoplaza.net/) 
    Permission is granted to copy, distribute and/or modify this document
    under the terms of the GNU Free Documentation License, Version 1.2
    or any later version published by the Free Software Foundation;
    with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
    Texts.  A copy of the license can be found at
    http://www.gnu.org/licenses/fdl.html
   
  Basically, it is free documentation in much the same way software under the
  GNU General Public License is free software. You can modify it, redistribute
  it, sell it, publish it, etc.

-------------------------------------------------------------------------------
| 3.0 Revision History
-------------------------------------------------------------------------------

  Version 1.0 - Friday, September 30, 2005
    - First Public Release

-------------------------------------------------------------------------------
| 4.0 Password Data
-------------------------------------------------------------------------------

  This is the important section. It covers the details of the Metroid password
  format.
  
-------------------------------------------------------------------------------
| 4.1 Basics
-------------------------------------------------------------------------------

  The Metroid Password is a string of 24 characters in the Metroid Alphabet.
  The password string is an encoded 144-bit data field, with 128 bits reserved
  for game data, 8 bits for the checksum, and 8 bits for the shift byte.
  
  Each character in the password represents 6 bits of the password (24 * 6 bits
  = 144 bits). To obtain the contiguous 144-bits, you will need to string the
  character bits together. After this has been done, you can perform operations
  on the comprising 18 individual bytes.
  
  There are 12 bits of the password data whose function is currently unknown.
  It is probable that some of the bits are unused. I have seen one in use, but
  have yet to discover it's function. If you learn the function of any of the
  bits marked Unknown in the document, I would very much appreciate an email.
  
  The remaining 116 bits are used to store data about the game. This data
  includes how many missiles Samus is carrying, what equipment Samus has in her 
  inventory (Long Beam, Maru Mari, etc), which missile containers Samus has
  picked up, which energy tanks Samus has collected, how long the game has been
  played, which red and yellow doors have been opened, Samus' starting
  location, which statues have been raised, if Samus is wearing her space suit  
  or her swimsuit, which zebetites have been destroyed, and finally which
  bosses have been killed.
  
  The password can be encrypted using a shift value, which is not part of the
  128-bit password data. It comprises the 8-bits just following the password
  data. More about the shift byte will be said in 4.4 The Shift Byte.
  
  The final 8 bits are the checksum, which is the first 136-bits added
  together. This provides Metroid a way to ensure that a valid password is
  being entered.
  
  Because the checksum is the same for every unique combination of the first
  136 bits, there are 2^136 valid Metroid passwords, which is approximately
  8.7112285931760246646623899502533e+40 passwords. Many of them are
  functionally equivalent.
  
-------------------------------------------------------------------------------
| 4.2 The Metroid Alphabet
-------------------------------------------------------------------------------

  Passwords, as well as all text in the game are comprised from an alphabet
  of 65 characters, which include the entire alphabet A-Z (both upper and lower
  case), the numbers 0-9, and the characters dash (-), question mark (?), and
  space ( ).
  
  Each character has a distinct value in a Metroid password, and they are
  ordered as follows:
  0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz?- 
  
  The space character, which is at the end carries a special value of 255. The
  remaining characters are all numbered from 0-63. In other words, the Metroid
  character 'C' has a value of 13.
  
  These values are used to decode the password into raw bit values. Because
  (with the exception of space), they can all be expressed in 6-bits. You may
  think that this means a space has the same value as the dash, but this is not
  entirely true. Because of the way the data is converted from 6-bit values to
  8-bit values (it is not simply strung together), the space can introduce it's
  high 2 bits over the lower order bits of the character which preceeded it.
  This means the space has the potential to alter the character which came
  before it. This will be discussed more in 4.7 Decoding.
  
-------------------------------------------------------------------------------
| 4.3 The Checksum
-------------------------------------------------------------------------------

  Metroid passwords use a simple checksum to confirm their authenticity as a
  valid Metroid password. The last 8-bits (1 byte) comprises the checksum.
  
  To calculate the checksum for a password, add the first 136 bits (17 bytes)
  together. Take the result bit-wise ANDed with 255 and you have your checksum.
  
  The checksum is not a perfect means of validation. It can only do a glib
  test stating that the data is likely to be what you meant to enter.
  
-------------------------------------------------------------------------------
| 4.4 The Shift Byte
-------------------------------------------------------------------------------

  The 17th byte (bits 128-135) comprise the shift byte. It is used to encrypt
  the password.
  
  Basically, when the password is encoded, bits are rotated from one byte to
  the next and the bit rotated off the last byte goes onto the first byte.
  
  The shift byte determines how many times this bit rotation occurs. So, a
  value of 0 means the password is not encrypted at all.
  
  The method for bit rotation will be covered in 4.6 Encoding and 4.7 Decoding.
  
-------------------------------------------------------------------------------
| 4.5 Known Password Bits
-------------------------------------------------------------------------------

  This section lists all the bits in the 128-bit password data that are known.
  I with I could be more specific about the locations of missile containers,
  energy tanks, and certain red doors, but without a good point of refernece
  (like a public map), this is difficult to do.
  
  There is another password generator written in Flash that contains a map and
  does a great job of telling you exactly where things are and which bit
  corresponds with what item. It is available at
  http://www.geocities.com/passgens/pages/metroid/metflash.htm. If you have
  Flash, and want to know specifics, I suggest you check it out.
  
  I'm going to list them in the order they exist in the password.
  
  Bit 0: Maru Mari Taken
  Bit 1: Missile Container (Brinstar)
  Bit 2: Red Door (Long Beam)
  Bit 3: Red Door (Tourian Bridge)
  Bit 4: Energy Tank (Brinstar)
  Bit 5: Red Door (Bombs)
  Bit 6: Bombs Taken
  Bit 7: Red Door (Ice Beam Brinstar)
  
  Bit 8: Missile Container (Brinstar)
  Bit 9: Energy Tank (Brinstar)
  Bit 10: Red Door (Varia)
  Bit 11: Varia Taken
  Bit 12: Energy Tank (Brinstar)
  Bit 13: Missile Container (Norfair)
  Bit 14: Missile Container (Norfair)
  Bit 15: Red Door (Ice Beam Norfair)
  
  Bit 16: Missile Container (Norfair)
  Bit 17: Missile Container (Norfair)
  Bit 18: Missile Container (Norfair)
  Bit 19: Missile Container (Norfair)
  Bit 20: Missile Container (Norfair)
  Bit 21: Missile Container (Norfair)
  Bit 22: Missile Container (Norfair)
  Bit 23: Red Door (High Jump Boots)
  
  Bit 24: High Jump Boots Taken
  Bit 25: Red Door (Screw Attack)
  Bit 26: Screw Attack Taken
  Bit 27: Missile Container (Norfair)
  Bit 28: Missile Container (Norfair)
  Bit 29: Red Door (Wave Beam)
  Bit 30: Energy Tank (Norfair)
  Bit 31: Missile Container (Norfair)
  
  Bit 32: Red Door (Kraid's Lair)
  Bit 33: Missile Container (Kraid's Lair)
  Bit 34: Missile Container (Kraid's Lair)
  Bit 35: Red Door (Kraid's Lair)
  Bit 36: Energy Tank (Kraid's Lair)
  Bit 37: Red Door (Kraid's Lair)
  Bit 38: Red Door (Kraid's Lair)
  Bit 39: Missile Container (Kraid's Lair)
  
  Bit 40: Missile Container (Kraid's Lair)
  Bit 41: Red Door (Kraid's Room)
  Bit 42: Energy Tank (Kraid's Room)
  Bit 43: Missile Container (Ridley's Lair)
  Bit 44: Red Door (Ridley's Lair)
  Bit 45: Energy Tank (Ridley's Lair)
  Bit 46: Missile Container (Ridley's Lair)
  Bit 47: Yellow Door (in Ridley's Room)
  
  Bit 48: Energy Tank (Room Behind Ridley)
  Bit 49: Missile Container (Ridley's Lair)
  Bit 50: Yellow Door (Tourian)
  Bit 51: Red Door (Tourian)
  Bit 52: Red Door (Tourian)
  Bit 53: Zebetite 1 Killed
  Bit 54: Zebetite 2 Killed
  Bit 55: Zebetite 3 Killed
  
  Bit 56: Zebetite 4 Killed
  Bit 57: Zebetite 5 Killed
  Bit 58: Mother Brain Killed
  Bit 59: Unknown
  Bit 60: Unknown
  Bit 61: Unknown
  Bit 62: Unknown
  Bit 63: Unknown
  
  Bit 64: Start in Norfair
  Bit 65: Start in Kraid's Lair
  Bit 66: Start in Ridley's Lair
  Bit 67: Reset
  Bit 68: Unknown
  Bit 69: Unknown
  Bit 70: Unknown
  Bit 71: Samus in Swimsuit
  
  Bit 72: Samus Has Bombs
  Bit 73: Samus Has High Jump Boots
  Bit 74: Samus Has Long Beam
  Bit 75: Samus Has Screw Attack
  Bit 76: Samus Has Maru Mari
  Bit 77: Samus Has Varia
  Bit 78: Samus Has Wave Beam
  Bit 79: Samus Has Ice Beam
  
  Bit 80: Missile Count (+1 Missile)
  Bit 81: Missile Count (+2 Missiles)
  Bit 82: Missile Count (+4 Missiles)
  Bit 83: Missile Count (+8 Missiles)
  Bit 84: Missile Count (+16 Missiles)
  Bit 85: Missile Count (+32 Missiles)
  Bit 86: Missile Count (+64 Missiles)
  Bit 87: Missile Count (+128 Missiles)
  
  Bit 88: Game Age (32-bit Value -- Low Bit)
  Bit 89: ...
  Bit 90: ...
  Bit 91: ...
  Bit 92: ...
  Bit 93: ...
  Bit 94: ...
  Bit 95: ...
  
  Bit 96: ...
  Bit 97: ...
  Bit 98: ...
  Bit 99: ...
  Bit 100: ...
  Bit 101: ...
  Bit 102: ...
  Bit 103: ...
  
  Bit 104: ...
  Bit 105: ...
  Bit 106: ...
  Bit 107: ...
  Bit 108: ...
  Bit 109: ...
  Bit 110: ...
  Bit 111: ...
  
  Bit 112: ...
  Bit 113: ...
  Bit 114: ...
  Bit 115: ...
  Bit 116: ...
  Bit 117: ...
  Bit 118: ...
  Bit 119: Game Age (32-bit Value -- High Bit)
  
  Bit 120: Unknown
  Bit 121: Unknown
  Bit 122: Unknown
  Bit 123: Unknown
  Bit 124: Ridley Killed
  Bit 125: Ridley Statue Raised
  Bit 126: Kraid Killed
  Bit 127: Kraid Statue Raised
  
  Most of these are obvious, but some require some additional explanation.
  
  The bits that say "XXX Taken", such as Maru Mari Taken, are used to determine
  whether the item will appear in the place it is supposed to be. If Samus
  doesn't have the Maru Mari (Bit 76), but Maru Mari is Taken (Bit 0), then
  Samus can never get the Maru Mari. All the beams (Long, Ice, and Wave) are
  always there.
  
  The game will not let you pick up the Ice Beam and Wave Beam simultaneously.
  If you pick up one, the other will deactivate. If you activate both bits
  yourself, you get a weird cross between the two beams. It doesn't seem to
  hurt the game.
  
  There are five valid start locations. They are specified using bits 64-66.
  To start in Brinstar, all the bits should be off. Norfair, Kraid's Lair, and
  Ridley's Lair can be specified by turning their bit on and leaving the others
  off. Tourian is specified by turning on Norfair and Kraid's Lair
  simultaneously. Any other combination of these three bits is invalid and will
  cause Metroid to reset.
  
  The reset bit is part of the start location. There are 16 possible values,
  but only 5 valid ones. Turning on the reset bit will produce and invalid
  start location and cause Metroid to reset. This is why it is called it is
  called the reset bit, because it guarantees an invalid password.
  
  If Mother Brain is dead, the door will already be there when you get to the
  end of Tourian. The bomb timer will not activate, and you will be able to
  spend as much time as you like escaping Tourian.
  
  The missile count is an 8-bit (1 byte) value ranging from 0-255. Just convert
  the number you want to binary and turn on the appropriate bits.
  
  The game age is a complicated number. It is a 32-bit value, though in
  reality, it only has a range of 2^24 * 208 because the least significant byte
  overflows at 208. This means there are 3,489,661,135 distinct values in the
  range 0 - 4,294,967,295.
  
  The game age is in what I will call 'game ticks'. The exact value of a tick
  depends upon whether you have an NTSC NES (the US Nintendo) or a PAL NES
  (the European Nintendo). If you have an NTSC NES, then 1 game tick = (256 /
  60) seconds or approximately 4.2666666666666666666666666666667 seconds. For a
  PAL NES, 1 game tick = (256 / 50) seconds or 5.12 seconds. Where did these
  values come from? 1 game tick is actually the amount of time it takes to
  draw 256 frames. Because the NTSC NES draws 60 frames per second, you get
  (256 / 60). The PAL NES draws 50 frames per second, so you get (256 / 50).
  The difference is related to television signal differences between North
  American (NTSC) and Europe (PAL).
  
-------------------------------------------------------------------------------
| 4.6 Encoding
-------------------------------------------------------------------------------

  Here comes the good part; taking the password data from its raw format and
  creating a Metroid password from it.
  
  The encode is a fairly simple process, although it involves a lot of tedious
  math. If you actually want to encode raw data, I highly recommend using a
  password generator, such as mpg (http://games.technoplaza.net/mpg/).
  
  The encoding process involves four steps.
    1. Calculate the checksum
    2. Encode the password data using the shift byte
    3. Convert the 18 8-bit blocks to 24 6-bit blocks
    4. Translate the 6-bit blocks into a readable password
    
  Step 1 - Calculate the Checksum
  
    Calculating the checksum is a fairly simple process. Take the first 136
    bits and add them together. Take the result and bit-wise and it with 255.
    The result if the checksum.
    
    The checksum should be stored in the last byte (bits 136-143).
    
  Step 2 - Encode the Password Data Using the Shift Byte
  
    This is the part where the password gets encrypted using bit rotation. Here
    is how it works.
    
    You need two variables, which I will call carry (1 bit) and copy (8 bits).
    
    As many times as the shift byte indicates, do the following
      Save the first byte of the password data in copy.
      
      For each byte of the password data (0-15 starting at 0) do the following
        Rotate the password byte right one bit.
          The least significant bit of the password byte should become the new
            carry value.
          The most significant bit of the password byte should be the old carry
            value.
          
      Rotate the copy byte right one bit.
        The least significant bit of copy should become the new carry value.
        The most significant bit of copy should be the old carry value.
      Overwrite the first byte of the password data with the copy byte.
      
    Very simply, we are rotating bits down the password data from byte to byte.
    The copy is needed because the last byte's rotated bit has to become the
    high bit of the first byte. I use the name carry because there is an
    instruction in x86 assembly which can perform this task using the carry
    flag internally. If you take a look at SnoBro's password generator MetCode,
    his x86 assembly source is much more compact than my C++ source for mpg.
    
  Step 3 - Convert the 18 8-bit Blocks to 24 6-bit Blocks
  
    Now that we have our password encoded using the shift byte, we can
    translate to the Metroid alphabet.
    
    Because each letter of the Metroid alphabet can be represented in 6-bits,
    the encoding process will never produce a password with spaces. You can
    read more about spaces in 4.7 Decoding.
    
    To convert from 8-bit blocks to 6-bit blocks, all we need to do is take
    every 6 bits in order. So just take your 144-bit string and separate it
    into 24 6-bit segments.
    
  Step 4 - Translate the 6-bit Blocks into a Readable Password
  
    Since each letter can be represented in 6-bits, converting between the
    6-bit blocks and the western alphabet is trivial. Convert each 6-bit
    value to a decimal number, and take that as the offset from 0 in the
    Metroid alphabet.
    
    In other words, 000000 binary = 0 decimal = '0'
                    111111 binary = 63 decimal = '-'
                    
    You can fill in the rest from 4.2 The Metroid Alphabet.
    
  That's all there is to it. The math is rote, but hard to do by hand. I highly
  recommend using a password generator if you want to actually encode Metroid
  passwords.
  
-------------------------------------------------------------------------------
| 4.7 Decoding
-------------------------------------------------------------------------------

  Decoding is nearly a mirror image of encoding, but there are a couple of
  minor differences that are important to note.
  
  Decoding, like encoding, is a four step process. Just like encoding, I
  recommend using a password generator if you really want to decode Metroid
  passwords.
  
    1. Convert the password to the Metroid alphabet
    2. Convert the 24 characters to 18 8-bit blocks
    3. Decode the password data using the shift byte
    4. Verify the checksum
    
  Step 1 - Convert the Password to the Metroid Alphabet
  
    This is basically the same as step 4 in the original, but we have to be
    careful, because we are not dealing with 6-bit blocks here. Although 64 of
    the 65 characters in the Metroid alphabet can be represented in 6-bits,
    the final character (space) cannot. Therefore, we must use 24 8-bit blocks,
    rather than 6-bit blocks.
    
    All the characters use their same values except for space which uses 255.
    In a minute, we will see how this causes spaces in passwords to sometimes
    affect the character that came before it.
    
  Step 2 - Convert the 24 characters to 18 8-bit blocks.
  
    Although we have 8-bit blocks now, we need to have 18 contiguous 8-bit
    blocks, and since most of the characters (if any) won't be spaces, we will
    have the upper two bits of every character off.
    
    If you have no spaces in the password, then you can just remove the leading
    two bits from each character and create a 144-bit string.
    
    If you have spaces, it gets more complicated. The character that preceeds
    the space must be altered to have its lowest two bits turned on. After
    that, you can treat the space like a dash.
    
    If you take a look at the source code for mpg, you can glean a more
    mathematical reason for why you have to do this with spaces, but for this
    document, I'm just doing to tell you that it has to be done.
    
  Step 3 - Decode the Password Data Using the Shift Byte
  
    This is the same process we did for encoding, but in reverse. Instead of
    rotating right, we rotate left, and we swap least significant bit and
    most significant bit. Here is the whole process.
    
    As many times as the shift byte indicates, do the following
      Save the last byte of the password data (byte 15) in copy.
      
      For each byte of the password data (15-0 starting at 15) do the following
        Rotate the password byte left one bit.
          The most significant bit of the password byte should become the new
            carry value.
          The least significant bit of the password byte should be the old
            carry value.
          
      Rotate the copy byte left one bit.
        The most significant bit of copy should become the new carry value.
        The least significant bit of copy should be the old carry value.
      Overwrite the last byte of the password data with the copy byte.
      
  Step 4 - Verify the Checksum
  
    Finally, we have our password data. Now we need to verify the checksum.
    
    All we have to do is calculate the checksum on the data we have, and make
    sure it's equal to byte 18 (bits 137-144). If not, then the password is
    not valid and will be rejected by Metroid.
    
  That's all there is to decoding.
  
-------------------------------------------------------------------------------
| 4.8 The Debug Password
-------------------------------------------------------------------------------

  One password, which I will call the debug password, and is also known as the
  NAR PASSWORD, is a special password which does not use the shift byte or the
  checksum. This is because it is hard coded into Metroid and the password data
  has no meaning. It simply triggers a debugging mode in Metroid that was used
  to help test the US version of the game.
  
  The NAR PASSWORD, which if written completely is
  
  NARPAS SWORD0
  0000
  
  The last 8 characters can be anything and are not checked at all. This is
  because 16 * 6 = 96 bits = 12 bytes = 3 quads. I don't know if this is
  specifically why you need the last 5 zeros, but it is my theory.
  
  Why 3 quads? I don't know, but it's a nice number from a computer science
  point of view. If not 3 quads, then 12 characters which would be 12 * 6 =
  72 bits = 9 bytes would have been pretty easy to check in 6502 assembly.
  
  It is also possible they simply wanted to restrict the number of passwords
  that would trigger debug mode, and requiring 5 zeros at the end is one way it
  could have been done. However, if that is the reason, why not require they
  all be zeros? Why have any wildcard characters at all?
  
  Blanks are interpreted as 0's in the Metroid password screen, so you never
  need to enter more than NARPAS SWORD anyways. (That's blank, meaning no
  character present, not space, which looks identical to, but is interpreted
  very differently from a blank).
  
  What does NAR mean? There are a few theories, but no one knows for sure. The
  three most popular are as follows:
  
    1. NAR = North American Release
       The Japanese version did not have passwords and used the FDS (Famicom
       Disk System) to store Metroid save games.
       
    2. NAR = Not a Real (as in Not a Real Password)
       
    3. NAR = Tohru Narihito
       Tohru Narihito designed and implemented the password system in Metroid.
       Maybe he named the debug password after himself.
       
-------------------------------------------------------------------------------
| 5.0 mpg - The Metroid Password Generator
-------------------------------------------------------------------------------

  As I have mentioned many times, it is inconvenient to use the methods
  described here by hand. This document wasn't written so people would try to
  do this by hand. Rather it was written to further the understanding of the
  Metroid password format.
  
  I wrote a program called mpg (The Metroid Password Generator) as a
  replacement for a program I had seen called MetCode (the first Metroid
  password creation tool written by SnoBro). SnoBro only updated it within
  his MetEdit (Metroid Editor) program, and the program itself leaves quite a
  lot to be desired. SnoBro did not have complete information on the password
  format, so many bits in the password that I learned about were blank in his
  program. It was also Windows only and has what I consider to be a less than
  optimal interface.
  
  mpg is a replacement for SnoBro's MetCode. It takes the basic idea and turns
  it into a nicer program. It runs on Windows, Linux, and Mac OS X for sure,
  but should also run on any unix supporting the GTK+ toolkit.
  
  mpg also takes inspiration from a program called metpass by tapper, which was
  written to aid in the creation of Metroid passwords as strings of words. If
  you want to spell words in Metroid Passwords, you could use metpass to fix
  the checksum so the password would work in Metroid. I thought the two ideas
  should be combined, so I added the features of metpass into mpg.
  
  I have spent a lot of time refining the interface, and although there are at
  least 5 other programs that create metroid passwords, I truly feel that mine
  is better than all of them. The one thing that it doesn't have that one of
  the others does is a reference map for where each item, red door, energy
  tank, and missile container is. It is written in Flash and will run in a
  web browser if you have the Flash plugin. You can find it at
  http://www.geocities.com/passgens/pages/metroid/metflash.htm. Despite his
  nice map, I still feel I have a better overall program.
  
  If you would like to use mpg, it is available for download at
  http://games.technoplaza.net/mpg/. It is free software under the GNU General
  Public License, comes with full source, and runs on nearly every platform.

-------------------------------------------------------------------------------
| 6.0 Credits & Acknowledgments
-------------------------------------------------------------------------------

  While I have learned a great deal on my own about the password format used in
  Metroid, much of my information comes originally from others. I will try to
  acknowledge everyone who has lead to the creation of this document here.
  
  SnoBro (aka Kent Hansen)
    Creator of SnoBro's Metroid Password Generator (MetCode) and MetEdit, an
    editor for Metroid ROMs. He did the original work on Metroid and learned
    the checksum and shift byte meanings, along with decoding the Metroid
    alphabet. I'm 99% positive that every Metroid password generator owes its
    existence to SnoBro and the original data he shared in his readme and
    source code. This include mpg. Thanks SnoBro!
    
  tapper (aka Sebastian Pettersson)
    Creator of metpass, a checksum generation utility that helps turn strings
    of words into valid Metroid passwords. His program inspired me to improve
    mpg beyond what I had originally envisioned and his readme contained
    information that helped me learn more about the password format.
    
  Xodnizel
    Creator of FCEU, an NES emulator with a debugger. I was able to confirm
    many of my theories about the password data using the debugger in FCEU.

-------------------------------------------------------------------------------
| 7.0 Contact Information
-------------------------------------------------------------------------------

  The author (John Ratliff) can be contacted at
  webmaster [AT] technoplaza [DOT] net. Replace as necessary.
  
  I can also be reached via an online feedback form at
  http://www.technoplaza.net/feedback.php

